// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/table_store/schemapb/schema.proto

package schemapb

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	io "io"
	math "math"
	math_bits "math/bits"
	typespb "px.dev/pixie/src/shared/types/typespb"
	px_dev_pixie_src_table_store_schemapb_types "px.dev/pixie/src/table_store/schemapb/types"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type BooleanColumn struct {
	Data []bool `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
}

func (m *BooleanColumn) Reset()      { *m = BooleanColumn{} }
func (*BooleanColumn) ProtoMessage() {}
func (*BooleanColumn) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{0}
}
func (m *BooleanColumn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BooleanColumn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BooleanColumn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BooleanColumn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BooleanColumn.Merge(m, src)
}
func (m *BooleanColumn) XXX_Size() int {
	return m.Size()
}
func (m *BooleanColumn) XXX_DiscardUnknown() {
	xxx_messageInfo_BooleanColumn.DiscardUnknown(m)
}

var xxx_messageInfo_BooleanColumn proto.InternalMessageInfo

func (m *BooleanColumn) GetData() []bool {
	if m != nil {
		return m.Data
	}
	return nil
}

type Int64Column struct {
	Data []int64 `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
}

func (m *Int64Column) Reset()      { *m = Int64Column{} }
func (*Int64Column) ProtoMessage() {}
func (*Int64Column) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{1}
}
func (m *Int64Column) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Int64Column) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Int64Column.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Int64Column) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Int64Column.Merge(m, src)
}
func (m *Int64Column) XXX_Size() int {
	return m.Size()
}
func (m *Int64Column) XXX_DiscardUnknown() {
	xxx_messageInfo_Int64Column.DiscardUnknown(m)
}

var xxx_messageInfo_Int64Column proto.InternalMessageInfo

func (m *Int64Column) GetData() []int64 {
	if m != nil {
		return m.Data
	}
	return nil
}

type UInt128Column struct {
	Data []*typespb.UInt128 `protobuf:"bytes,1,rep,name=data,proto3" json:"data,omitempty"`
}

func (m *UInt128Column) Reset()      { *m = UInt128Column{} }
func (*UInt128Column) ProtoMessage() {}
func (*UInt128Column) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{2}
}
func (m *UInt128Column) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *UInt128Column) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_UInt128Column.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *UInt128Column) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UInt128Column.Merge(m, src)
}
func (m *UInt128Column) XXX_Size() int {
	return m.Size()
}
func (m *UInt128Column) XXX_DiscardUnknown() {
	xxx_messageInfo_UInt128Column.DiscardUnknown(m)
}

var xxx_messageInfo_UInt128Column proto.InternalMessageInfo

func (m *UInt128Column) GetData() []*typespb.UInt128 {
	if m != nil {
		return m.Data
	}
	return nil
}

type Float64Column struct {
	Data []float64 `protobuf:"fixed64,1,rep,packed,name=data,proto3" json:"data,omitempty"`
}

func (m *Float64Column) Reset()      { *m = Float64Column{} }
func (*Float64Column) ProtoMessage() {}
func (*Float64Column) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{3}
}
func (m *Float64Column) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Float64Column) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Float64Column.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Float64Column) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Float64Column.Merge(m, src)
}
func (m *Float64Column) XXX_Size() int {
	return m.Size()
}
func (m *Float64Column) XXX_DiscardUnknown() {
	xxx_messageInfo_Float64Column.DiscardUnknown(m)
}

var xxx_messageInfo_Float64Column proto.InternalMessageInfo

func (m *Float64Column) GetData() []float64 {
	if m != nil {
		return m.Data
	}
	return nil
}

type Time64NSColumn struct {
	Data []int64 `protobuf:"varint,1,rep,packed,name=data,proto3" json:"data,omitempty"`
}

func (m *Time64NSColumn) Reset()      { *m = Time64NSColumn{} }
func (*Time64NSColumn) ProtoMessage() {}
func (*Time64NSColumn) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{4}
}
func (m *Time64NSColumn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Time64NSColumn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Time64NSColumn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Time64NSColumn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Time64NSColumn.Merge(m, src)
}
func (m *Time64NSColumn) XXX_Size() int {
	return m.Size()
}
func (m *Time64NSColumn) XXX_DiscardUnknown() {
	xxx_messageInfo_Time64NSColumn.DiscardUnknown(m)
}

var xxx_messageInfo_Time64NSColumn proto.InternalMessageInfo

func (m *Time64NSColumn) GetData() []int64 {
	if m != nil {
		return m.Data
	}
	return nil
}

type StringColumn struct {
	Data []px_dev_pixie_src_table_store_schemapb_types.StringData `protobuf:"bytes,1,rep,name=data,proto3,customtype=px.dev/pixie/src/table_store/schemapb/types.StringData" json:"data,omitempty"`
}

func (m *StringColumn) Reset()      { *m = StringColumn{} }
func (*StringColumn) ProtoMessage() {}
func (*StringColumn) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{5}
}
func (m *StringColumn) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StringColumn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StringColumn.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StringColumn) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StringColumn.Merge(m, src)
}
func (m *StringColumn) XXX_Size() int {
	return m.Size()
}
func (m *StringColumn) XXX_DiscardUnknown() {
	xxx_messageInfo_StringColumn.DiscardUnknown(m)
}

var xxx_messageInfo_StringColumn proto.InternalMessageInfo

type Column struct {
	// Types that are valid to be assigned to ColData:
	//
	//	*Column_BooleanData
	//	*Column_Int64Data
	//	*Column_Uint128Data
	//	*Column_Time64NsData
	//	*Column_Float64Data
	//	*Column_StringData
	ColData isColumn_ColData `protobuf_oneof:"col_data"`
}

func (m *Column) Reset()      { *m = Column{} }
func (*Column) ProtoMessage() {}
func (*Column) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{6}
}
func (m *Column) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Column) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Column.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Column) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Column.Merge(m, src)
}
func (m *Column) XXX_Size() int {
	return m.Size()
}
func (m *Column) XXX_DiscardUnknown() {
	xxx_messageInfo_Column.DiscardUnknown(m)
}

var xxx_messageInfo_Column proto.InternalMessageInfo

type isColumn_ColData interface {
	isColumn_ColData()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Column_BooleanData struct {
	BooleanData *BooleanColumn `protobuf:"bytes,1,opt,name=boolean_data,json=booleanData,proto3,oneof" json:"boolean_data,omitempty"`
}
type Column_Int64Data struct {
	Int64Data *Int64Column `protobuf:"bytes,2,opt,name=int64_data,json=int64Data,proto3,oneof" json:"int64_data,omitempty"`
}
type Column_Uint128Data struct {
	Uint128Data *UInt128Column `protobuf:"bytes,3,opt,name=uint128_data,json=uint128Data,proto3,oneof" json:"uint128_data,omitempty"`
}
type Column_Time64NsData struct {
	Time64NsData *Time64NSColumn `protobuf:"bytes,4,opt,name=time64ns_data,json=time64nsData,proto3,oneof" json:"time64ns_data,omitempty"`
}
type Column_Float64Data struct {
	Float64Data *Float64Column `protobuf:"bytes,5,opt,name=float64_data,json=float64Data,proto3,oneof" json:"float64_data,omitempty"`
}
type Column_StringData struct {
	StringData *StringColumn `protobuf:"bytes,6,opt,name=string_data,json=stringData,proto3,oneof" json:"string_data,omitempty"`
}

func (*Column_BooleanData) isColumn_ColData()  {}
func (*Column_Int64Data) isColumn_ColData()    {}
func (*Column_Uint128Data) isColumn_ColData()  {}
func (*Column_Time64NsData) isColumn_ColData() {}
func (*Column_Float64Data) isColumn_ColData()  {}
func (*Column_StringData) isColumn_ColData()   {}

func (m *Column) GetColData() isColumn_ColData {
	if m != nil {
		return m.ColData
	}
	return nil
}

func (m *Column) GetBooleanData() *BooleanColumn {
	if x, ok := m.GetColData().(*Column_BooleanData); ok {
		return x.BooleanData
	}
	return nil
}

func (m *Column) GetInt64Data() *Int64Column {
	if x, ok := m.GetColData().(*Column_Int64Data); ok {
		return x.Int64Data
	}
	return nil
}

func (m *Column) GetUint128Data() *UInt128Column {
	if x, ok := m.GetColData().(*Column_Uint128Data); ok {
		return x.Uint128Data
	}
	return nil
}

func (m *Column) GetTime64NsData() *Time64NSColumn {
	if x, ok := m.GetColData().(*Column_Time64NsData); ok {
		return x.Time64NsData
	}
	return nil
}

func (m *Column) GetFloat64Data() *Float64Column {
	if x, ok := m.GetColData().(*Column_Float64Data); ok {
		return x.Float64Data
	}
	return nil
}

func (m *Column) GetStringData() *StringColumn {
	if x, ok := m.GetColData().(*Column_StringData); ok {
		return x.StringData
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Column) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Column_BooleanData)(nil),
		(*Column_Int64Data)(nil),
		(*Column_Uint128Data)(nil),
		(*Column_Time64NsData)(nil),
		(*Column_Float64Data)(nil),
		(*Column_StringData)(nil),
	}
}

type RowBatchData struct {
	Cols    []*Column `protobuf:"bytes,1,rep,name=cols,proto3" json:"cols,omitempty"`
	NumRows int64     `protobuf:"varint,2,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"`
	Eow     bool      `protobuf:"varint,3,opt,name=eow,proto3" json:"eow,omitempty"`
	Eos     bool      `protobuf:"varint,4,opt,name=eos,proto3" json:"eos,omitempty"`
}

func (m *RowBatchData) Reset()      { *m = RowBatchData{} }
func (*RowBatchData) ProtoMessage() {}
func (*RowBatchData) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{7}
}
func (m *RowBatchData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RowBatchData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RowBatchData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RowBatchData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RowBatchData.Merge(m, src)
}
func (m *RowBatchData) XXX_Size() int {
	return m.Size()
}
func (m *RowBatchData) XXX_DiscardUnknown() {
	xxx_messageInfo_RowBatchData.DiscardUnknown(m)
}

var xxx_messageInfo_RowBatchData proto.InternalMessageInfo

func (m *RowBatchData) GetCols() []*Column {
	if m != nil {
		return m.Cols
	}
	return nil
}

func (m *RowBatchData) GetNumRows() int64 {
	if m != nil {
		return m.NumRows
	}
	return 0
}

func (m *RowBatchData) GetEow() bool {
	if m != nil {
		return m.Eow
	}
	return false
}

func (m *RowBatchData) GetEos() bool {
	if m != nil {
		return m.Eos
	}
	return false
}

type Relation struct {
	Columns []*Relation_ColumnInfo `protobuf:"bytes,1,rep,name=columns,proto3" json:"columns,omitempty"`
	Desc    string                 `protobuf:"bytes,2,opt,name=desc,proto3" json:"desc,omitempty"`
}

func (m *Relation) Reset()      { *m = Relation{} }
func (*Relation) ProtoMessage() {}
func (*Relation) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{8}
}
func (m *Relation) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Relation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Relation.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Relation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Relation.Merge(m, src)
}
func (m *Relation) XXX_Size() int {
	return m.Size()
}
func (m *Relation) XXX_DiscardUnknown() {
	xxx_messageInfo_Relation.DiscardUnknown(m)
}

var xxx_messageInfo_Relation proto.InternalMessageInfo

func (m *Relation) GetColumns() []*Relation_ColumnInfo {
	if m != nil {
		return m.Columns
	}
	return nil
}

func (m *Relation) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

type Relation_ColumnInfo struct {
	ColumnName         string               `protobuf:"bytes,1,opt,name=column_name,json=columnName,proto3" json:"column_name,omitempty"`
	ColumnType         typespb.DataType     `protobuf:"varint,2,opt,name=column_type,json=columnType,proto3,enum=px.types.DataType" json:"column_type,omitempty"`
	ColumnDesc         string               `protobuf:"bytes,3,opt,name=column_desc,json=columnDesc,proto3" json:"column_desc,omitempty"`
	ColumnSemanticType typespb.SemanticType `protobuf:"varint,4,opt,name=column_semantic_type,json=columnSemanticType,proto3,enum=px.types.SemanticType" json:"column_semantic_type,omitempty"`
	PatternType        typespb.PatternType  `protobuf:"varint,5,opt,name=pattern_type,json=patternType,proto3,enum=px.types.PatternType" json:"pattern_type,omitempty"`
}

func (m *Relation_ColumnInfo) Reset()      { *m = Relation_ColumnInfo{} }
func (*Relation_ColumnInfo) ProtoMessage() {}
func (*Relation_ColumnInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{8, 0}
}
func (m *Relation_ColumnInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Relation_ColumnInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Relation_ColumnInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Relation_ColumnInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Relation_ColumnInfo.Merge(m, src)
}
func (m *Relation_ColumnInfo) XXX_Size() int {
	return m.Size()
}
func (m *Relation_ColumnInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_Relation_ColumnInfo.DiscardUnknown(m)
}

var xxx_messageInfo_Relation_ColumnInfo proto.InternalMessageInfo

func (m *Relation_ColumnInfo) GetColumnName() string {
	if m != nil {
		return m.ColumnName
	}
	return ""
}

func (m *Relation_ColumnInfo) GetColumnType() typespb.DataType {
	if m != nil {
		return m.ColumnType
	}
	return typespb.DATA_TYPE_UNKNOWN
}

func (m *Relation_ColumnInfo) GetColumnDesc() string {
	if m != nil {
		return m.ColumnDesc
	}
	return ""
}

func (m *Relation_ColumnInfo) GetColumnSemanticType() typespb.SemanticType {
	if m != nil {
		return m.ColumnSemanticType
	}
	return typespb.ST_UNSPECIFIED
}

func (m *Relation_ColumnInfo) GetPatternType() typespb.PatternType {
	if m != nil {
		return m.PatternType
	}
	return typespb.UNSPECIFIED
}

type Table struct {
	Relation   *Relation       `protobuf:"bytes,4,opt,name=relation,proto3" json:"relation,omitempty"`
	RowBatches []*RowBatchData `protobuf:"bytes,5,rep,name=row_batches,json=rowBatches,proto3" json:"row_batches,omitempty"`
	Name       string          `protobuf:"bytes,6,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *Table) Reset()      { *m = Table{} }
func (*Table) ProtoMessage() {}
func (*Table) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{9}
}
func (m *Table) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Table) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Table.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Table) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Table.Merge(m, src)
}
func (m *Table) XXX_Size() int {
	return m.Size()
}
func (m *Table) XXX_DiscardUnknown() {
	xxx_messageInfo_Table.DiscardUnknown(m)
}

var xxx_messageInfo_Table proto.InternalMessageInfo

func (m *Table) GetRelation() *Relation {
	if m != nil {
		return m.Relation
	}
	return nil
}

func (m *Table) GetRowBatches() []*RowBatchData {
	if m != nil {
		return m.RowBatches
	}
	return nil
}

func (m *Table) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type Schema struct {
	RelationMap map[string]*Relation `protobuf:"bytes,1,rep,name=relation_map,json=relationMap,proto3" json:"relation_map,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *Schema) Reset()      { *m = Schema{} }
func (*Schema) ProtoMessage() {}
func (*Schema) Descriptor() ([]byte, []int) {
	return fileDescriptor_837edaf494876c32, []int{10}
}
func (m *Schema) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Schema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Schema.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Schema) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Schema.Merge(m, src)
}
func (m *Schema) XXX_Size() int {
	return m.Size()
}
func (m *Schema) XXX_DiscardUnknown() {
	xxx_messageInfo_Schema.DiscardUnknown(m)
}

var xxx_messageInfo_Schema proto.InternalMessageInfo

func (m *Schema) GetRelationMap() map[string]*Relation {
	if m != nil {
		return m.RelationMap
	}
	return nil
}

func init() {
	proto.RegisterType((*BooleanColumn)(nil), "px.table_store.schemapb.BooleanColumn")
	proto.RegisterType((*Int64Column)(nil), "px.table_store.schemapb.Int64Column")
	proto.RegisterType((*UInt128Column)(nil), "px.table_store.schemapb.UInt128Column")
	proto.RegisterType((*Float64Column)(nil), "px.table_store.schemapb.Float64Column")
	proto.RegisterType((*Time64NSColumn)(nil), "px.table_store.schemapb.Time64NSColumn")
	proto.RegisterType((*StringColumn)(nil), "px.table_store.schemapb.StringColumn")
	proto.RegisterType((*Column)(nil), "px.table_store.schemapb.Column")
	proto.RegisterType((*RowBatchData)(nil), "px.table_store.schemapb.RowBatchData")
	proto.RegisterType((*Relation)(nil), "px.table_store.schemapb.Relation")
	proto.RegisterType((*Relation_ColumnInfo)(nil), "px.table_store.schemapb.Relation.ColumnInfo")
	proto.RegisterType((*Table)(nil), "px.table_store.schemapb.Table")
	proto.RegisterType((*Schema)(nil), "px.table_store.schemapb.Schema")
	proto.RegisterMapType((map[string]*Relation)(nil), "px.table_store.schemapb.Schema.RelationMapEntry")
}

func init() {
	proto.RegisterFile("src/table_store/schemapb/schema.proto", fileDescriptor_837edaf494876c32)
}

var fileDescriptor_837edaf494876c32 = []byte{
	// 825 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x95, 0xcf, 0x6f, 0xe3, 0x44,
	0x14, 0xc7, 0xed, 0xa6, 0xc9, 0xa6, 0xcf, 0xee, 0x6a, 0x19, 0xf1, 0x63, 0xe9, 0xc1, 0x65, 0xb3,
	0x2d, 0xec, 0x01, 0x1c, 0x68, 0x57, 0xa5, 0x5a, 0x09, 0x0e, 0x61, 0xb7, 0x4a, 0xb5, 0x22, 0x42,
	0x93, 0x72, 0xe1, 0x40, 0x34, 0x76, 0xa7, 0x89, 0x85, 0xed, 0xb1, 0x3c, 0x93, 0x4d, 0x73, 0x43,
	0x5c, 0xb8, 0xf2, 0x37, 0x70, 0xe2, 0xcf, 0xe0, 0xc8, 0xb1, 0xc7, 0x15, 0x42, 0x88, 0xa6, 0x17,
	0x8e, 0xfd, 0x13, 0x90, 0xdf, 0x8c, 0x1b, 0x07, 0xd5, 0x94, 0x4b, 0xfb, 0x66, 0xfc, 0x7d, 0x9f,
	0xf7, 0xfa, 0xbe, 0xcf, 0x35, 0xec, 0xca, 0x3c, 0xec, 0x2a, 0x16, 0xc4, 0x7c, 0x24, 0x95, 0xc8,
	0x79, 0x57, 0x86, 0x13, 0x9e, 0xb0, 0x2c, 0x30, 0x81, 0x9f, 0xe5, 0x42, 0x09, 0xf2, 0x4e, 0x76,
	0xee, 0x57, 0x54, 0x7e, 0xa9, 0xda, 0xfa, 0x68, 0x1c, 0xa9, 0xc9, 0x34, 0xf0, 0x43, 0x91, 0x74,
	0xc7, 0x62, 0x2c, 0xba, 0xa8, 0x0f, 0xa6, 0x67, 0x78, 0xc2, 0x03, 0x46, 0x9a, 0xb3, 0xb5, 0x53,
	0x94, 0x93, 0x13, 0x96, 0xf3, 0xd3, 0xae, 0x9a, 0x67, 0x5c, 0xea, 0x9f, 0x59, 0xa0, 0x7f, 0x6b,
	0x55, 0xe7, 0x31, 0x6c, 0xf6, 0x84, 0x88, 0x39, 0x4b, 0xbf, 0x10, 0xf1, 0x34, 0x49, 0x09, 0x81,
	0xf5, 0x53, 0xa6, 0xd8, 0x43, 0xfb, 0xbd, 0xc6, 0x93, 0x36, 0xc5, 0xb8, 0xf3, 0x08, 0x9c, 0xe3,
	0x54, 0x1d, 0x3c, 0xbd, 0x45, 0xd2, 0x30, 0x92, 0x03, 0xd8, 0xfc, 0xfa, 0x38, 0x55, 0x9f, 0xec,
	0x1d, 0x1a, 0xd1, 0x6e, 0x45, 0xe4, 0xec, 0xbd, 0xe1, 0x17, 0x7f, 0x15, 0xd6, 0x35, 0x32, 0x93,
	0xf7, 0x18, 0x36, 0x8f, 0x62, 0xc1, 0x6e, 0x87, 0xdb, 0x46, 0xb4, 0x03, 0xf7, 0x4f, 0xa2, 0x84,
	0x1f, 0x3c, 0x1d, 0x0c, 0xff, 0xa3, 0x85, 0x6f, 0xc1, 0x1d, 0xaa, 0x3c, 0x4a, 0xc7, 0x46, 0x33,
	0xa8, 0x68, 0xdc, 0xde, 0xb3, 0xdf, 0xff, 0xdc, 0x3e, 0xc8, 0xce, 0xfd, 0x53, 0xfe, 0xaa, 0x9b,
	0x45, 0xe7, 0x11, 0xef, 0xd6, 0xda, 0xa1, 0xfb, 0xd4, 0xac, 0xe7, 0x4c, 0x31, 0xc3, 0xff, 0xa3,
	0x01, 0x2d, 0x83, 0x7e, 0x09, 0x6e, 0xa0, 0xa7, 0x36, 0x32, 0x25, 0xec, 0x27, 0xce, 0xde, 0xfb,
	0x7e, 0x8d, 0x75, 0xfe, 0xca, 0x88, 0xfb, 0x16, 0x75, 0x4c, 0x76, 0x41, 0x27, 0x2f, 0x00, 0xa2,
	0x62, 0xba, 0x1a, 0xb5, 0x86, 0xa8, 0x9d, 0x5a, 0x54, 0xc5, 0x88, 0xbe, 0x45, 0x37, 0x30, 0x13,
	0x31, 0x2f, 0xc1, 0x9d, 0x46, 0x38, 0x5a, 0x0d, 0x6a, 0xdc, 0xd1, 0xd3, 0x8a, 0x5d, 0x45, 0x4f,
	0x26, 0x1b, 0x61, 0x03, 0xd8, 0x54, 0x38, 0xf1, 0x54, 0x6a, 0xda, 0x3a, 0xd2, 0x3e, 0xa8, 0xa5,
	0xad, 0xfa, 0xd3, 0xb7, 0xa8, 0x5b, 0xe6, 0x97, 0xcd, 0x9d, 0x69, 0x9b, 0x35, 0xae, 0x79, 0x47,
	0x73, 0x2b, 0x3b, 0x51, 0x34, 0x67, 0xb2, 0x11, 0xd6, 0x07, 0x47, 0xa2, 0x39, 0x9a, 0xd5, 0x42,
	0xd6, 0x6e, 0x2d, 0xab, 0xba, 0x14, 0x7d, 0x8b, 0x82, 0xbc, 0x31, 0xb6, 0x07, 0xd0, 0x0e, 0x45,
	0x8c, 0x98, 0xce, 0x0f, 0x36, 0xb8, 0x54, 0xcc, 0x7a, 0x4c, 0x85, 0x13, 0x2c, 0xb3, 0x0f, 0xeb,
	0xa1, 0x88, 0xa5, 0xd9, 0xe0, 0xed, 0x5a, 0xbe, 0x26, 0x53, 0x14, 0x93, 0x77, 0xa1, 0x9d, 0x4e,
	0x93, 0x51, 0x2e, 0x66, 0x12, 0xad, 0x6c, 0xd0, 0x7b, 0xe9, 0x34, 0xa1, 0x62, 0x26, 0xc9, 0x03,
	0x68, 0x70, 0x31, 0x43, 0x5f, 0xda, 0xb4, 0x08, 0xf5, 0x8d, 0xc4, 0xd9, 0xe2, 0x8d, 0xec, 0x5c,
	0xaf, 0x41, 0x9b, 0xf2, 0x98, 0xa9, 0x48, 0xa4, 0xe4, 0x08, 0xee, 0x85, 0xc8, 0x2e, 0x7b, 0xf8,
	0xb0, 0xb6, 0x87, 0x32, 0xc7, 0x34, 0x73, 0x9c, 0x9e, 0x09, 0x5a, 0x26, 0xe3, 0xcb, 0xc2, 0x65,
	0x88, 0xfd, 0x6c, 0x50, 0x8c, 0xb7, 0x7e, 0x5c, 0x03, 0x58, 0x6a, 0xc9, 0x36, 0x38, 0x5a, 0x3d,
	0x4a, 0x59, 0xc2, 0x71, 0x9f, 0x37, 0x28, 0xe8, 0xab, 0x01, 0x4b, 0x38, 0xd9, 0xbf, 0x11, 0x14,
	0x6f, 0x07, 0xa2, 0xee, 0xef, 0x91, 0xe5, 0x5b, 0x5d, 0x4c, 0xec, 0x64, 0x9e, 0xf1, 0x32, 0xa9,
	0x88, 0x2b, 0x54, 0xac, 0xdf, 0xa8, 0x52, 0x9f, 0x73, 0x19, 0x92, 0x3e, 0xbc, 0x69, 0x04, 0x92,
	0x27, 0x2c, 0x55, 0x51, 0xa8, 0xf1, 0xeb, 0x88, 0x7f, 0x7b, 0x89, 0x1f, 0x9a, 0xc7, 0x58, 0x82,
	0xe8, 0x9c, 0xea, 0x1d, 0x39, 0x04, 0x37, 0x63, 0x4a, 0xf1, 0xdc, 0x34, 0xd8, 0x44, 0xc2, 0x5b,
	0x4b, 0xc2, 0x57, 0xfa, 0x29, 0x02, 0x9c, 0x6c, 0x79, 0xe8, 0xfc, 0x6c, 0x43, 0xf3, 0xa4, 0x98,
	0x29, 0xf9, 0x0c, 0xda, 0xb9, 0x99, 0xa3, 0xd9, 0xf7, 0x47, 0x77, 0x0e, 0x9c, 0xde, 0xa4, 0x90,
	0x23, 0x70, 0x72, 0x31, 0x1b, 0x05, 0xc5, 0x02, 0x71, 0xf9, 0xb0, 0x89, 0x96, 0xd5, 0xaf, 0x65,
	0x75, 0xd7, 0x28, 0xe4, 0xe6, 0xc4, 0xd1, 0x2e, 0x34, 0xa1, 0xa5, 0xed, 0x2a, 0xe2, 0xce, 0xaf,
	0x36, 0xb4, 0x86, 0x98, 0x49, 0x86, 0xe0, 0x96, 0x25, 0x47, 0x09, 0xcb, 0xcc, 0x6a, 0x7c, 0x5c,
	0xbf, 0xfe, 0xfa, 0xe3, 0x52, 0x36, 0xfc, 0x25, 0xcb, 0x5e, 0xa4, 0x2a, 0x9f, 0x53, 0x27, 0x5f,
	0xde, 0x6c, 0x31, 0x78, 0xf0, 0x6f, 0x41, 0xb1, 0x9d, 0xdf, 0xf1, 0xb9, 0xd9, 0x85, 0x22, 0x24,
	0x9f, 0x42, 0xf3, 0x15, 0x8b, 0xa7, 0xdc, 0xfc, 0x93, 0xfa, 0x1f, 0xd3, 0xd1, 0xfa, 0x67, 0x6b,
	0x87, 0x76, 0xef, 0xf3, 0x8b, 0x4b, 0xcf, 0x7a, 0x7d, 0xe9, 0x59, 0xd7, 0x97, 0x9e, 0xfd, 0xfd,
	0xc2, 0xb3, 0x7f, 0x59, 0x78, 0xf6, 0x6f, 0x0b, 0xcf, 0xbe, 0x58, 0x78, 0xf6, 0x5f, 0x0b, 0xcf,
	0xfe, 0x7b, 0xe1, 0x59, 0xd7, 0x0b, 0xcf, 0xfe, 0xe9, 0xca, 0xb3, 0x2e, 0xae, 0x3c, 0xeb, 0xf5,
	0x95, 0x67, 0x7d, 0xd3, 0x2e, 0x99, 0x41, 0x0b, 0x3f, 0x58, 0xfb, 0xff, 0x04, 0x00, 0x00, 0xff,
	0xff, 0xbd, 0x31, 0x06, 0x07, 0x47, 0x07, 0x00, 0x00,
}

func (this *BooleanColumn) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BooleanColumn)
	if !ok {
		that2, ok := that.(BooleanColumn)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if this.Data[i] != that1.Data[i] {
			return false
		}
	}
	return true
}
func (this *Int64Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Int64Column)
	if !ok {
		that2, ok := that.(Int64Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if this.Data[i] != that1.Data[i] {
			return false
		}
	}
	return true
}
func (this *UInt128Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*UInt128Column)
	if !ok {
		that2, ok := that.(UInt128Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if !this.Data[i].Equal(that1.Data[i]) {
			return false
		}
	}
	return true
}
func (this *Float64Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Float64Column)
	if !ok {
		that2, ok := that.(Float64Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if this.Data[i] != that1.Data[i] {
			return false
		}
	}
	return true
}
func (this *Time64NSColumn) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Time64NSColumn)
	if !ok {
		that2, ok := that.(Time64NSColumn)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if this.Data[i] != that1.Data[i] {
			return false
		}
	}
	return true
}
func (this *StringColumn) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*StringColumn)
	if !ok {
		that2, ok := that.(StringColumn)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Data) != len(that1.Data) {
		return false
	}
	for i := range this.Data {
		if !this.Data[i].Equal(that1.Data[i]) {
			return false
		}
	}
	return true
}
func (this *Column) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column)
	if !ok {
		that2, ok := that.(Column)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if that1.ColData == nil {
		if this.ColData != nil {
			return false
		}
	} else if this.ColData == nil {
		return false
	} else if !this.ColData.Equal(that1.ColData) {
		return false
	}
	return true
}
func (this *Column_BooleanData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_BooleanData)
	if !ok {
		that2, ok := that.(Column_BooleanData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.BooleanData.Equal(that1.BooleanData) {
		return false
	}
	return true
}
func (this *Column_Int64Data) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_Int64Data)
	if !ok {
		that2, ok := that.(Column_Int64Data)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Int64Data.Equal(that1.Int64Data) {
		return false
	}
	return true
}
func (this *Column_Uint128Data) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_Uint128Data)
	if !ok {
		that2, ok := that.(Column_Uint128Data)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Uint128Data.Equal(that1.Uint128Data) {
		return false
	}
	return true
}
func (this *Column_Time64NsData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_Time64NsData)
	if !ok {
		that2, ok := that.(Column_Time64NsData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Time64NsData.Equal(that1.Time64NsData) {
		return false
	}
	return true
}
func (this *Column_Float64Data) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_Float64Data)
	if !ok {
		that2, ok := that.(Column_Float64Data)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Float64Data.Equal(that1.Float64Data) {
		return false
	}
	return true
}
func (this *Column_StringData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Column_StringData)
	if !ok {
		that2, ok := that.(Column_StringData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.StringData.Equal(that1.StringData) {
		return false
	}
	return true
}
func (this *RowBatchData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RowBatchData)
	if !ok {
		that2, ok := that.(RowBatchData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Cols) != len(that1.Cols) {
		return false
	}
	for i := range this.Cols {
		if !this.Cols[i].Equal(that1.Cols[i]) {
			return false
		}
	}
	if this.NumRows != that1.NumRows {
		return false
	}
	if this.Eow != that1.Eow {
		return false
	}
	if this.Eos != that1.Eos {
		return false
	}
	return true
}
func (this *Relation) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Relation)
	if !ok {
		that2, ok := that.(Relation)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Columns) != len(that1.Columns) {
		return false
	}
	for i := range this.Columns {
		if !this.Columns[i].Equal(that1.Columns[i]) {
			return false
		}
	}
	if this.Desc != that1.Desc {
		return false
	}
	return true
}
func (this *Relation_ColumnInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Relation_ColumnInfo)
	if !ok {
		that2, ok := that.(Relation_ColumnInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ColumnName != that1.ColumnName {
		return false
	}
	if this.ColumnType != that1.ColumnType {
		return false
	}
	if this.ColumnDesc != that1.ColumnDesc {
		return false
	}
	if this.ColumnSemanticType != that1.ColumnSemanticType {
		return false
	}
	if this.PatternType != that1.PatternType {
		return false
	}
	return true
}
func (this *Table) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Table)
	if !ok {
		that2, ok := that.(Table)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Relation.Equal(that1.Relation) {
		return false
	}
	if len(this.RowBatches) != len(that1.RowBatches) {
		return false
	}
	for i := range this.RowBatches {
		if !this.RowBatches[i].Equal(that1.RowBatches[i]) {
			return false
		}
	}
	if this.Name != that1.Name {
		return false
	}
	return true
}
func (this *Schema) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Schema)
	if !ok {
		that2, ok := that.(Schema)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.RelationMap) != len(that1.RelationMap) {
		return false
	}
	for i := range this.RelationMap {
		if !this.RelationMap[i].Equal(that1.RelationMap[i]) {
			return false
		}
	}
	return true
}
func (this *BooleanColumn) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&schemapb.BooleanColumn{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Int64Column) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&schemapb.Int64Column{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *UInt128Column) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&schemapb.UInt128Column{")
	if this.Data != nil {
		s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Float64Column) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&schemapb.Float64Column{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Time64NSColumn) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&schemapb.Time64NSColumn{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *StringColumn) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&schemapb.StringColumn{")
	s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Column) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&schemapb.Column{")
	if this.ColData != nil {
		s = append(s, "ColData: "+fmt.Sprintf("%#v", this.ColData)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Column_BooleanData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&schemapb.Column_BooleanData{` +
		`BooleanData:` + fmt.Sprintf("%#v", this.BooleanData) + `}`}, ", ")
	return s
}
func (this *Column_Int64Data) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&schemapb.Column_Int64Data{` +
		`Int64Data:` + fmt.Sprintf("%#v", this.Int64Data) + `}`}, ", ")
	return s
}
func (this *Column_Uint128Data) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&schemapb.Column_Uint128Data{` +
		`Uint128Data:` + fmt.Sprintf("%#v", this.Uint128Data) + `}`}, ", ")
	return s
}
func (this *Column_Time64NsData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&schemapb.Column_Time64NsData{` +
		`Time64NsData:` + fmt.Sprintf("%#v", this.Time64NsData) + `}`}, ", ")
	return s
}
func (this *Column_Float64Data) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&schemapb.Column_Float64Data{` +
		`Float64Data:` + fmt.Sprintf("%#v", this.Float64Data) + `}`}, ", ")
	return s
}
func (this *Column_StringData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&schemapb.Column_StringData{` +
		`StringData:` + fmt.Sprintf("%#v", this.StringData) + `}`}, ", ")
	return s
}
func (this *RowBatchData) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 8)
	s = append(s, "&schemapb.RowBatchData{")
	if this.Cols != nil {
		s = append(s, "Cols: "+fmt.Sprintf("%#v", this.Cols)+",\n")
	}
	s = append(s, "NumRows: "+fmt.Sprintf("%#v", this.NumRows)+",\n")
	s = append(s, "Eow: "+fmt.Sprintf("%#v", this.Eow)+",\n")
	s = append(s, "Eos: "+fmt.Sprintf("%#v", this.Eos)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Relation) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&schemapb.Relation{")
	if this.Columns != nil {
		s = append(s, "Columns: "+fmt.Sprintf("%#v", this.Columns)+",\n")
	}
	s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Relation_ColumnInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&schemapb.Relation_ColumnInfo{")
	s = append(s, "ColumnName: "+fmt.Sprintf("%#v", this.ColumnName)+",\n")
	s = append(s, "ColumnType: "+fmt.Sprintf("%#v", this.ColumnType)+",\n")
	s = append(s, "ColumnDesc: "+fmt.Sprintf("%#v", this.ColumnDesc)+",\n")
	s = append(s, "ColumnSemanticType: "+fmt.Sprintf("%#v", this.ColumnSemanticType)+",\n")
	s = append(s, "PatternType: "+fmt.Sprintf("%#v", this.PatternType)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Table) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&schemapb.Table{")
	if this.Relation != nil {
		s = append(s, "Relation: "+fmt.Sprintf("%#v", this.Relation)+",\n")
	}
	if this.RowBatches != nil {
		s = append(s, "RowBatches: "+fmt.Sprintf("%#v", this.RowBatches)+",\n")
	}
	s = append(s, "Name: "+fmt.Sprintf("%#v", this.Name)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Schema) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&schemapb.Schema{")
	keysForRelationMap := make([]string, 0, len(this.RelationMap))
	for k, _ := range this.RelationMap {
		keysForRelationMap = append(keysForRelationMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRelationMap)
	mapStringForRelationMap := "map[string]*Relation{"
	for _, k := range keysForRelationMap {
		mapStringForRelationMap += fmt.Sprintf("%#v: %#v,", k, this.RelationMap[k])
	}
	mapStringForRelationMap += "}"
	if this.RelationMap != nil {
		s = append(s, "RelationMap: "+mapStringForRelationMap+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringSchema(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *BooleanColumn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BooleanColumn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BooleanColumn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			i--
			if m.Data[iNdEx] {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
		}
		i = encodeVarintSchema(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Int64Column) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Int64Column) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Int64Column) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		dAtA2 := make([]byte, len(m.Data)*10)
		var j1 int
		for _, num1 := range m.Data {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintSchema(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UInt128Column) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *UInt128Column) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UInt128Column) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Data[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchema(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Float64Column) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Float64Column) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Float64Column) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			f3 := math.Float64bits(float64(m.Data[iNdEx]))
			i -= 8
			encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(f3))
		}
		i = encodeVarintSchema(dAtA, i, uint64(len(m.Data)*8))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Time64NSColumn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Time64NSColumn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Time64NSColumn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		dAtA5 := make([]byte, len(m.Data)*10)
		var j4 int
		for _, num1 := range m.Data {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		i -= j4
		copy(dAtA[i:], dAtA5[:j4])
		i = encodeVarintSchema(dAtA, i, uint64(j4))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StringColumn) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StringColumn) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StringColumn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Data) > 0 {
		for iNdEx := len(m.Data) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Data[iNdEx].Size()
				i -= size
				if _, err := m.Data[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintSchema(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Column) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Column) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ColData != nil {
		{
			size := m.ColData.Size()
			i -= size
			if _, err := m.ColData.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	return len(dAtA) - i, nil
}

func (m *Column_BooleanData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_BooleanData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.BooleanData != nil {
		{
			size, err := m.BooleanData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchema(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}
func (m *Column_Int64Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_Int64Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Int64Data != nil {
		{
			size, err := m.Int64Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchema(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}
func (m *Column_Uint128Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_Uint128Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Uint128Data != nil {
		{
			size, err := m.Uint128Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchema(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	return len(dAtA) - i, nil
}
func (m *Column_Time64NsData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_Time64NsData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Time64NsData != nil {
		{
			size, err := m.Time64NsData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchema(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}
func (m *Column_Float64Data) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_Float64Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Float64Data != nil {
		{
			size, err := m.Float64Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchema(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *Column_StringData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Column_StringData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.StringData != nil {
		{
			size, err := m.StringData.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchema(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *RowBatchData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RowBatchData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RowBatchData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Eos {
		i--
		if m.Eos {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Eow {
		i--
		if m.Eow {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.NumRows != 0 {
		i = encodeVarintSchema(dAtA, i, uint64(m.NumRows))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Cols) > 0 {
		for iNdEx := len(m.Cols) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Cols[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchema(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Relation) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Relation) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Relation) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Desc) > 0 {
		i -= len(m.Desc)
		copy(dAtA[i:], m.Desc)
		i = encodeVarintSchema(dAtA, i, uint64(len(m.Desc)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Columns) > 0 {
		for iNdEx := len(m.Columns) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Columns[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchema(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *Relation_ColumnInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Relation_ColumnInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Relation_ColumnInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PatternType != 0 {
		i = encodeVarintSchema(dAtA, i, uint64(m.PatternType))
		i--
		dAtA[i] = 0x28
	}
	if m.ColumnSemanticType != 0 {
		i = encodeVarintSchema(dAtA, i, uint64(m.ColumnSemanticType))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ColumnDesc) > 0 {
		i -= len(m.ColumnDesc)
		copy(dAtA[i:], m.ColumnDesc)
		i = encodeVarintSchema(dAtA, i, uint64(len(m.ColumnDesc)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ColumnType != 0 {
		i = encodeVarintSchema(dAtA, i, uint64(m.ColumnType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ColumnName) > 0 {
		i -= len(m.ColumnName)
		copy(dAtA[i:], m.ColumnName)
		i = encodeVarintSchema(dAtA, i, uint64(len(m.ColumnName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Table) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Table) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Table) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintSchema(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.RowBatches) > 0 {
		for iNdEx := len(m.RowBatches) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.RowBatches[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintSchema(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Relation != nil {
		{
			size, err := m.Relation.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintSchema(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	return len(dAtA) - i, nil
}

func (m *Schema) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Schema) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Schema) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RelationMap) > 0 {
		for k := range m.RelationMap {
			v := m.RelationMap[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintSchema(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintSchema(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintSchema(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintSchema(dAtA []byte, offset int, v uint64) int {
	offset -= sovSchema(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *BooleanColumn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		n += 1 + sovSchema(uint64(len(m.Data))) + len(m.Data)*1
	}
	return n
}

func (m *Int64Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		l = 0
		for _, e := range m.Data {
			l += sovSchema(uint64(e))
		}
		n += 1 + sovSchema(uint64(l)) + l
	}
	return n
}

func (m *UInt128Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		for _, e := range m.Data {
			l = e.Size()
			n += 1 + l + sovSchema(uint64(l))
		}
	}
	return n
}

func (m *Float64Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		n += 1 + sovSchema(uint64(len(m.Data)*8)) + len(m.Data)*8
	}
	return n
}

func (m *Time64NSColumn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		l = 0
		for _, e := range m.Data {
			l += sovSchema(uint64(e))
		}
		n += 1 + sovSchema(uint64(l)) + l
	}
	return n
}

func (m *StringColumn) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Data) > 0 {
		for _, e := range m.Data {
			l = e.Size()
			n += 1 + l + sovSchema(uint64(l))
		}
	}
	return n
}

func (m *Column) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ColData != nil {
		n += m.ColData.Size()
	}
	return n
}

func (m *Column_BooleanData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BooleanData != nil {
		l = m.BooleanData.Size()
		n += 1 + l + sovSchema(uint64(l))
	}
	return n
}
func (m *Column_Int64Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Int64Data != nil {
		l = m.Int64Data.Size()
		n += 1 + l + sovSchema(uint64(l))
	}
	return n
}
func (m *Column_Uint128Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Uint128Data != nil {
		l = m.Uint128Data.Size()
		n += 1 + l + sovSchema(uint64(l))
	}
	return n
}
func (m *Column_Time64NsData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Time64NsData != nil {
		l = m.Time64NsData.Size()
		n += 1 + l + sovSchema(uint64(l))
	}
	return n
}
func (m *Column_Float64Data) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Float64Data != nil {
		l = m.Float64Data.Size()
		n += 1 + l + sovSchema(uint64(l))
	}
	return n
}
func (m *Column_StringData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StringData != nil {
		l = m.StringData.Size()
		n += 1 + l + sovSchema(uint64(l))
	}
	return n
}
func (m *RowBatchData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Cols) > 0 {
		for _, e := range m.Cols {
			l = e.Size()
			n += 1 + l + sovSchema(uint64(l))
		}
	}
	if m.NumRows != 0 {
		n += 1 + sovSchema(uint64(m.NumRows))
	}
	if m.Eow {
		n += 2
	}
	if m.Eos {
		n += 2
	}
	return n
}

func (m *Relation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Columns) > 0 {
		for _, e := range m.Columns {
			l = e.Size()
			n += 1 + l + sovSchema(uint64(l))
		}
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovSchema(uint64(l))
	}
	return n
}

func (m *Relation_ColumnInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ColumnName)
	if l > 0 {
		n += 1 + l + sovSchema(uint64(l))
	}
	if m.ColumnType != 0 {
		n += 1 + sovSchema(uint64(m.ColumnType))
	}
	l = len(m.ColumnDesc)
	if l > 0 {
		n += 1 + l + sovSchema(uint64(l))
	}
	if m.ColumnSemanticType != 0 {
		n += 1 + sovSchema(uint64(m.ColumnSemanticType))
	}
	if m.PatternType != 0 {
		n += 1 + sovSchema(uint64(m.PatternType))
	}
	return n
}

func (m *Table) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Relation != nil {
		l = m.Relation.Size()
		n += 1 + l + sovSchema(uint64(l))
	}
	if len(m.RowBatches) > 0 {
		for _, e := range m.RowBatches {
			l = e.Size()
			n += 1 + l + sovSchema(uint64(l))
		}
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovSchema(uint64(l))
	}
	return n
}

func (m *Schema) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.RelationMap) > 0 {
		for k, v := range m.RelationMap {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovSchema(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovSchema(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovSchema(uint64(mapEntrySize))
		}
	}
	return n
}

func sovSchema(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozSchema(x uint64) (n int) {
	return sovSchema(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *BooleanColumn) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BooleanColumn{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Int64Column) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Int64Column{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *UInt128Column) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForData := "[]*UInt128{"
	for _, f := range this.Data {
		repeatedStringForData += strings.Replace(fmt.Sprintf("%v", f), "UInt128", "typespb.UInt128", 1) + ","
	}
	repeatedStringForData += "}"
	s := strings.Join([]string{`&UInt128Column{`,
		`Data:` + repeatedStringForData + `,`,
		`}`,
	}, "")
	return s
}
func (this *Float64Column) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Float64Column{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Time64NSColumn) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Time64NSColumn{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StringColumn) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StringColumn{`,
		`Data:` + fmt.Sprintf("%v", this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column{`,
		`ColData:` + fmt.Sprintf("%v", this.ColData) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_BooleanData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_BooleanData{`,
		`BooleanData:` + strings.Replace(fmt.Sprintf("%v", this.BooleanData), "BooleanColumn", "BooleanColumn", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_Int64Data) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_Int64Data{`,
		`Int64Data:` + strings.Replace(fmt.Sprintf("%v", this.Int64Data), "Int64Column", "Int64Column", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_Uint128Data) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_Uint128Data{`,
		`Uint128Data:` + strings.Replace(fmt.Sprintf("%v", this.Uint128Data), "UInt128Column", "UInt128Column", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_Time64NsData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_Time64NsData{`,
		`Time64NsData:` + strings.Replace(fmt.Sprintf("%v", this.Time64NsData), "Time64NSColumn", "Time64NSColumn", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_Float64Data) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_Float64Data{`,
		`Float64Data:` + strings.Replace(fmt.Sprintf("%v", this.Float64Data), "Float64Column", "Float64Column", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Column_StringData) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Column_StringData{`,
		`StringData:` + strings.Replace(fmt.Sprintf("%v", this.StringData), "StringColumn", "StringColumn", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RowBatchData) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForCols := "[]*Column{"
	for _, f := range this.Cols {
		repeatedStringForCols += strings.Replace(f.String(), "Column", "Column", 1) + ","
	}
	repeatedStringForCols += "}"
	s := strings.Join([]string{`&RowBatchData{`,
		`Cols:` + repeatedStringForCols + `,`,
		`NumRows:` + fmt.Sprintf("%v", this.NumRows) + `,`,
		`Eow:` + fmt.Sprintf("%v", this.Eow) + `,`,
		`Eos:` + fmt.Sprintf("%v", this.Eos) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Relation) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForColumns := "[]*Relation_ColumnInfo{"
	for _, f := range this.Columns {
		repeatedStringForColumns += strings.Replace(fmt.Sprintf("%v", f), "Relation_ColumnInfo", "Relation_ColumnInfo", 1) + ","
	}
	repeatedStringForColumns += "}"
	s := strings.Join([]string{`&Relation{`,
		`Columns:` + repeatedStringForColumns + `,`,
		`Desc:` + fmt.Sprintf("%v", this.Desc) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Relation_ColumnInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Relation_ColumnInfo{`,
		`ColumnName:` + fmt.Sprintf("%v", this.ColumnName) + `,`,
		`ColumnType:` + fmt.Sprintf("%v", this.ColumnType) + `,`,
		`ColumnDesc:` + fmt.Sprintf("%v", this.ColumnDesc) + `,`,
		`ColumnSemanticType:` + fmt.Sprintf("%v", this.ColumnSemanticType) + `,`,
		`PatternType:` + fmt.Sprintf("%v", this.PatternType) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Table) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForRowBatches := "[]*RowBatchData{"
	for _, f := range this.RowBatches {
		repeatedStringForRowBatches += strings.Replace(f.String(), "RowBatchData", "RowBatchData", 1) + ","
	}
	repeatedStringForRowBatches += "}"
	s := strings.Join([]string{`&Table{`,
		`Relation:` + strings.Replace(this.Relation.String(), "Relation", "Relation", 1) + `,`,
		`RowBatches:` + repeatedStringForRowBatches + `,`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Schema) String() string {
	if this == nil {
		return "nil"
	}
	keysForRelationMap := make([]string, 0, len(this.RelationMap))
	for k, _ := range this.RelationMap {
		keysForRelationMap = append(keysForRelationMap, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRelationMap)
	mapStringForRelationMap := "map[string]*Relation{"
	for _, k := range keysForRelationMap {
		mapStringForRelationMap += fmt.Sprintf("%v: %v,", k, this.RelationMap[k])
	}
	mapStringForRelationMap += "}"
	s := strings.Join([]string{`&Schema{`,
		`RelationMap:` + mapStringForRelationMap + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringSchema(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *BooleanColumn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BooleanColumn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BooleanColumn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchema
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Data = append(m.Data, bool(v != 0))
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchema
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSchema
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSchema
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen
				if elementCount != 0 && len(m.Data) == 0 {
					m.Data = make([]bool, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchema
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Data = append(m.Data, bool(v != 0))
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Int64Column) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Int64Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Int64Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchema
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Data = append(m.Data, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchema
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSchema
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSchema
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Data) == 0 {
					m.Data = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchema
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Data = append(m.Data, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *UInt128Column) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: UInt128Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UInt128Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data, &typespb.UInt128{})
			if err := m.Data[len(m.Data)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Float64Column) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Float64Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Float64Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 1 {
				var v uint64
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
				v2 := float64(math.Float64frombits(v))
				m.Data = append(m.Data, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchema
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSchema
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSchema
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 8
				if elementCount != 0 && len(m.Data) == 0 {
					m.Data = make([]float64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					if (iNdEx + 8) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
					iNdEx += 8
					v2 := float64(math.Float64frombits(v))
					m.Data = append(m.Data, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Time64NSColumn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Time64NSColumn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Time64NSColumn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchema
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Data = append(m.Data, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchema
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthSchema
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthSchema
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Data) == 0 {
					m.Data = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchema
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Data = append(m.Data, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StringColumn) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StringColumn: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StringColumn: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v px_dev_pixie_src_table_store_schemapb_types.StringData
			m.Data = append(m.Data, v)
			if err := m.Data[len(m.Data)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Column) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Column: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Column: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BooleanData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BooleanColumn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_BooleanData{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Int64Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Int64Column{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_Int64Data{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uint128Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &UInt128Column{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_Uint128Data{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time64NsData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Time64NSColumn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_Time64NsData{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Float64Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Float64Column{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_Float64Data{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &StringColumn{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.ColData = &Column_StringData{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RowBatchData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RowBatchData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RowBatchData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cols", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cols = append(m.Cols, &Column{})
			if err := m.Cols[len(m.Cols)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumRows", wireType)
			}
			m.NumRows = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumRows |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Eow", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Eow = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Eos", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Eos = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Relation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Relation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Relation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Columns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Columns = append(m.Columns, &Relation_ColumnInfo{})
			if err := m.Columns[len(m.Columns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Relation_ColumnInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ColumnInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColumnInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnType", wireType)
			}
			m.ColumnType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ColumnType |= typespb.DataType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnDesc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ColumnDesc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ColumnSemanticType", wireType)
			}
			m.ColumnSemanticType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ColumnSemanticType |= typespb.SemanticType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PatternType", wireType)
			}
			m.PatternType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PatternType |= typespb.PatternType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Table) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Table: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Table: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Relation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Relation == nil {
				m.Relation = &Relation{}
			}
			if err := m.Relation.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RowBatches", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RowBatches = append(m.RowBatches, &RowBatchData{})
			if err := m.RowBatches[len(m.RowBatches)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Schema) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Schema: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Schema: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RelationMap", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthSchema
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthSchema
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RelationMap == nil {
				m.RelationMap = make(map[string]*Relation)
			}
			var mapkey string
			var mapvalue *Relation
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowSchema
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchema
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthSchema
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthSchema
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowSchema
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthSchema
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthSchema
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &Relation{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipSchema(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthSchema
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RelationMap[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipSchema(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthSchema
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipSchema(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowSchema
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowSchema
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthSchema
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupSchema
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthSchema
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthSchema        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowSchema          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupSchema = fmt.Errorf("proto: unexpected end of group")
)
